עקרונות שפות תכנות 2016 תרגול 8 Type Inference System. Substitution Interpreter.

Transcription

1 עקרונות שפות תכנות 2016 תרגול 8 Type Inference System. Substitution Interpreter. Type Inference System The Type Inference System is a Scheme Implementation of the algorithm for Type Checking and Inference using Type Constraints presented in Section 5.5 of the Course Book. System Architecture The system is built from the following modules: The layers of the system are: - Abstract Syntax for Scheme Expressions and for Type Expressions. - The key data types manipulated in the algorithm, Type Equations and Type Substitutions. - The logic of the algorithm is implemented in three functional packages: Scheme-Exp-to-Pool, Scheme-Exp-to-Equations and the top-level algorithm Solve. The key interfaces of each package are the following: 1

2 Layer 1: Languages Definitions The Type Inference algorithm maps expressions in one language (Scheme expressions) into expressions in another language (Type Expressions). The lower level of the Type Inference system implements the Abstract Syntax interfaces for expressions in these two languages. Scheme-AST: Implements parser and abstract syntax for the following BNF concrete syntax: BNF <scheme-expression> := <scheme-exp > <scheme-define> <scheme-exp> := <scheme-atomic> <scheme-composite> <scheme-define> := '(' 'define' <scheme-var> <scheme-exp> ')' <scheme-atomic> := <scheme-var> <number> <bool> <scheme-composite> := <scheme-proc> <scheme-app> <scheme-let> <scheme-let*> <scheme-letrec> <scheme-if> <scheme-proc> := '(' 'lambda' '(' <scheme-var>* ')' <scheme-exp>+ ')' <scheme-app> := '(' <scheme-exp>+ ')' <scheme-let> := '(' 'let' '(' <scheme-binding>* ')' <scheme-exp>+ ')' <scheme-let*> := '(' 'let*' '(' <scheme-binding>* ')' <scheme-exp>+ ')' <scheme-letrec> := '(' 'letrec' '(' <scheme-binding>* ')' <scheme-exp>+ ')' <scheme-if> := '(' 'if' <scheme-exp> <scheme-exp> <scheme-exp> ')' <scheme-binding> := '(' <scheme-var> <scheme-exp> ')' Scheme Abstract syntax: Scheme-define: Components var:scheme-var val:scheme-exp Scheme-proc: Components vars:list(scheme-var) body:list(scheme-exp) Scheme-app: Components operator:scheme-exp operands:list(scheme-exp) Scheme-let: Components: bindings:list(pair(scheme-var, Scheme-exp)) body:list(scheme-exp) Scheme-let*: Components: bindings:list(pair(scheme-var, Scheme-exp)) body:list(scheme-exp) Scheme-letrec: Components: bindings:list(pair(scheme-var, Scheme-exp)) body:list(scheme-exp) Scheme-if: Components: test:scheme-exp then:scheme-exp else:scheme-exp Type-Expression-ADT: BNF (Concrete syntax) for Type-Expressions TE -> Atomic-te Composite-te Type-variable Atomic-te -> "Number" "Boolean" Composite-te -> Proc-te Tuple-te Non-Tuple-te -> Atomic-te Proc-te Type-variable Proc-te -> "[" Tuple-te "->" Non-Tuple-te "]" Tuple-te -> (Non-Tuple-te "*")* Non-Tuple-te "Empty" Type-variable -> a symbol starting with an upper case 2

3 Abstract Syntax for Type-Expressions: Tuple-te: Components: List(Non-Tuple-te) Proc-te: Components: Parameters: Tuple-te Return: Non-Tuple-te The parser for Type-Expressions has an element of complexity because it must deal with the precedence of operators among type sub-expressions (* and ->). It uses a parsing algorithm called "shift-reduce" to parse expressions such as [T1 * T2 -> T3] into an expression understood as (-> (* T1 T2) T3) as opposed to (* T1 (-> T2 T3)). The situation is similar to the well-known precedence rules of arithmetic expressions where a parser knows to interpret [2*3+5] as (+ (* 2 3) 5). This logic is implemented in the package Type-Expression-Parser and relies on a Stack data structure to implement the Shift-Reduce algorithm. Layer 2: Substitution and Equation ADTs The Type Inference algorithm is defined in terms of 2 basic formal tools: Type Substitutions are finite mappings of Type Variables to Type Expressions. Equations are pairs that state that a left Type Expression is to be held equivalent to a right Type Expression. Substitution ADT The interface of the Substitution ADT includes: make-sub(variables, type-expressions) sub->expression-of-variable(sub,var): lookup a variable in a substitution extend-sub(sub,var,te) sub-apply(sub,te) sub-combine(sub1,sub2) Equation ADT The interface includes: make-equation(tel, ter) equation->left(eq) equation->right(eq) Layer 3: Scheme-Exp-to-Pool, Scheme-Exp-to-Equations, Solve scheme-exp->pool(exp) traverses the AST of a Scheme Expression and maps each sub-expression in the AST to distinct Type Variables. pool->equations(pool) applies type formulae to propagate constraints from the syntactic structure of the Scheme Expression to constraints among the type variables of the pool. There are specific constraints derived for each type of syntactic construct according to the semantics of the Scheme programming language. infer-type(scheme-expr) applies the whole logic of the type inference algorithm. The main steps of the algorithm are reflected in this top-level fragment: (let* ((pool (scheme-exp->pool scheme-exp)) (equations (pool->equations pool)) (sub (solve-equations equations)) (te (val-of-index scheme-exp pool))) 3

4 The key logic of the algorithm lies in the solve-equations algorithm which turns a list of Type Equations into a single coherent Type Substitution which satisfies all the constraints. Solve() relies on the computation of unification between two type expressions. Exercise: Extend the Type Inference system to support "If" expressions The part of the Type Inference System which "knows" Scheme Expressions is the function make-equation-from-se(se,pool). The structure of this function is a case for each type of Scheme expression. The code we provided supports: Procedure Application Number Boolean Primitive Procedures Extend the code to support Scheme expressions of the type (if <test> <then> <else>). Remember question 2 from last week's practical session. From Typing Rule for if-expressions the type equations derived from a composite if-expression: (if _p _c _a) we derive 2 equations: T c = T a T if = T c Accordingly, the code of the function make-equation-from-se is extended to process if-exp ;; Signature: make-equation-from-se(se,pool) ;; Purpose: Return a single equation ;; Type: [Scheme-expression * Pool -> Equation] ;; Pre-condition: 'se' is a legal Scheme expression, and ;; 'se' is a member of 'pool' (define make-equation-from-se (lambda (se pool) (letrec ((get-tvar-of-exp (lambda (exp) (val-of-index exp pool)))) (cond ;; The type of procedure is (T1 *... * Tn -> Te) ;; where Te is the type of the last exp in the body of the proc. ;; and Ti is the type of each of the parameters. ((scheme-proc? se) (let ((left (get-tvar-of-exp se)) (right (make-proc-te (make-tuple-te (map get-tvar-of-exp (scheme-proc->vars se))) (get-tvar-of-exp (last (scheme-proc->body se)))))) (list (make-equation left right)))) ;; An application must respect the type of its operator ;; Type(Operator) = [T1 *.. * Tn -> Te] ;; Type(Application) = Te ((scheme-app? se) (let ((left (get-tvar-of-exp (scheme-app->operator se))) (right (make-proc-te 4

5 (make-tuple-te (map get-tvar-of-exp (scheme-app->operands se))) (get-tvar-of-exp se)))) (list (make-equation left right)))) ;; Support if-expressions: ;; [if <test> <then> <else>) --> ;; {[T<then> = T<else>], [T<true> = T<if>]} ((scheme-if? se) (let ((Tif (get-tvar-of-exp se)) (Tt (get-tvar-of-exp (scheme-if->then se))) (Te (get-tvar-of-exp (scheme-if->else se)))) (list (make-equation Tif Tt) (make-equation Tt Te)))) ;; The type of a number is Number ((number? se) (let ((left (get-tvar-of-exp se)) (right 'Number)) (list (make-equation left right)))) ;; The type of a boolean is Boolean ((boolean? se) (let ((left (get-tvar-of-exp se)) (right 'Boolean)) (list (make-equation left right)))) ;; The type of a primitive procedure is given by the primitive. ((primitive-procedure? se) (let ((left (get-tvar-of-exp se)) (right (get-primitive-type se))) (list (make-equation left right)))) (else (error 'make-equation "Bad expression ~s" se)))))) 5

6 מבנה המעריך מעריך עבור מודל ההחלפה <scheme-expression> Data structures substitution values Utils A Racket lib Core Test Abstract syntax parser Derived expressions איור המעריך מתחיל עם ביטוי scheme ולאחר מכן מבצע derivation ו- evaluation. מנגנון הבדיקות : 1 מבנה המעריך מבוסס מודל ההחלפה. חץ מסמל שימוש של מודול במודול אחר, למשל ה- Core משתמש ב- DS וב- ASP מרכיב חשוב במעריך הוא מנגנון הבדיקות. בדיקות הן חלק בלתי נפרד מפיתוח תוכנה והן הכרחיות, קל וחומר בתוכנה מורכבת כמו מעריך. רכיב הבדיקות במעריך מורכב משתי פרוצדורות עיקריות: test ו- run-tests. חשוב: כאשר משנים או מוסיפים קוד למעריך )או לכל תוכנית(, מריצים את כל הבדיקות! כך נדע שלא פגענו ברכיב שכבר עובד ונבדק בעבר. הפרוצדורה test מקבלת ביטוי וערך צפוי, מעריכה את הביטוי ובודקת האם תוצאת החישוב שווה לתוצאה המצופה. לדוגמה: (test (derive-eval '(* 3 4)) => '(value 12)) הפרוצדורה run-tests מקבלת מספר לא מוגבל מראש של ביטויי,test מריצה אותם, ומסכמת את התוצאות: (run-tests (test (derive-eval '(+ 3 4)) => '(value 7)) (test (derive-eval '(- 3 4)) => '(value -1)) (test (derive-eval '(/ 4 2)) => '(value 2))) כדי להוסיף בדיקה חדשה פשוט נפעיל את הפרוצדורה test עם הפרמטרים הרצויים מתוך אחד ה- run-tests הקיימים, או שנכתוב run-tests בעצמנו. לדוגמה, אנו רוצים להוסיף בדיקה כי המעריך שלנו מעריך את הביטוי "4" לערך 4. אזי נוסיף את השורה הבאה לקובץ הבדיקות: (run-tests (test (derive-eval '4) => '(value 4))) נקודה לדיון: מדוע יש לתייג את תוצאת החישוב ב- (4 '(value ולא ניתן פשוט להחזיר את הערך 4? ליבת המעריך )core( חלקי הליבה החלק המרכזי של ליבת המעריך מורכב משתי פרוצדורות עם הפניה הדדית ביניהן: applicative-eval apply-procedure 6

7 הפרוצדורה applicative-eval מקבלת כפרמטר ביטוי,scheme כאשר סוג הביטוי הוא אחד מהסוגים ברשימה למטה, ועבור כל אחד מהסוגים הללו, מצוינת דרך הפעולה: applicative-eval(exp): atomic?(exp) eval-atomic (exp) special-form?(exp) eval-special-form (exp) evaluator-value?(exp) exp application?(exp) apply-procedure(applicative-eval(operator(exp)), list-of-values(operands(exp))) הפרוצדורה apply-procedure מקבלת שני פרמטרים: הפרוצדורה אותה רוצים להפעיל ואת הפרמטרים עבורה: apply-procedure(evaluated_proc, evaluated_args): primitive-procedure?(evaluated_proc) apply-primitive-procedure(evaluated_proc,evaluate_args) compound-procedure?(evaluated_proc) params procedure-parameters(evaluated_proc) body rename(procedure-body(evaluated_proc)) eval-sequence(substitute(body, params, evaluated_args))) )הקריאה ההדדית ל- applicative-eval היא בתוך.)eval-sequence אם הפרוצדורה היא פרימיטיבית, מפעילים אותה על הפרמטרים )שכבר הוערכו(. אם הפרוצדורה אינה פרימיטיבית, אזי מבצעים rename לכל המשתנים הקשורים בגוף הפרוצדורה. נשים לב כי פעולת ה- rename מתבצעת רק על גוף הפרוצדורה. אחרי פעולת ה- rename, אין יותר צורך לבדוק מיהם המשתנים הקשורים כדי לבצע substitute פשוט מחליפים לפי שם המשתנה. פרוצדורת ה- substitute הנמצאת ב- ge-adt מקבלת את גוף הפרוצדורה, את הפרמטרים של הפרוצדורה ואת הארגומנטים שאיתם הופעלה הפרוצדורה ומייצרת החלפה שתופעל על הגוף. מדוע צריך לעשות rename רק לגוף הפרוצדורה ללא הפרמטרים שהפרוצדורה מקבלת? תזכורת: הבעיה ש- rename פותר. נסתכל על הקוד הבא: 1. ((lambda (x) 2. (lambda (y) 3. (y x))) 4. (lambda (x) 5. (+ x y))) ה- y בשורה 5 הוא משתנה חופשי. כאשר נבצע הערכה של הביטוי כולו, ה- x בשורה 3 יוחלף על ידי ה- lambda בשורות 4-5. ללא,renaming ה- y החופשי בשורה 5 ייקשר ל- y אשר מוגדר בשורה 2. כלומר, הבעיה שלנו נובעת מתוך הלמבדות בגוף הפרוצדורה. המשתנה x המוגדר בשורה 1 מוחלף מיד על ידי הפרמטר ואינו מהווה בעיה. אופרטורים מיוחדים Forms Special )שינוי/הוספת.)Special Form אופרטורים מיוחדים הינם אופרטורים שיש עבורם חוק חישוב מיוחד. בד"כ לא מוסיפים,special form אלא אם אין ברירה אחרת, מדוע? בכל מקרה, נראה דוגמא של הוספת ביטוי חדש לשפה:,case המקבל ביטוי מספרי ובהתאם לערכו מבצע פעולה כלשהי. (case <numeric_expression> (<value0> <consequence0>) (<value1> <consequence1>) (else <consequence_n>)) 7 הצורה התחבירית של ביטוי :case

8 (define fib (lambda (n) (case n (0 0) (1 1) (else (+ (fib (- n 1)) (fib (- n 2))))))) דוגמה לשימוש בביטוי :case תזכורת: and-or-trees לייצוג :ast <case> Predicate AND Consequence-exprs: Ordered. <exp> <exp>+ (define eval-special-form (lambda (exp) (cond ((quoted? 1 exp) (make-value 2 exp)) ((lambda? 1 exp) (eval-lambda 3 exp)) ((definition? 1 exp) (eval-definition 3 exp)) ((if? 1 exp) (eval-if 3 exp)) ((begin? 1 exp) (eval-begin 3 exp)) ((case? 1 exp) (eval-case 3 exp))))) (define special-form? (lambda (exp) (or (quoted? exp) (lambda? exp) (definition? exp) (if? exp) (begin? exp) (case? exp)))) צעד 1: עדכון.eval-special-form צעד 2: עדכן.special-form? צעד 3: כתיבת חוק החישוב המיוחד. ראשית אנו צריכים לקבוע מהו חוק החישוב של :case הערכת ה- control השוואת ערך ה- control לערכי ה- compared לפי הסדר. הנחנו כי הערך הוא מספרי ולכן ההשוואה מתבצעת ע"י "=". 8 פונקציות אשר ניתנות לנו מהממשק של ASP פונקציות אשר ניתנות לנו ממודל מבני הנתונים של המעריך פונקציות אשר נמצאות בליבת המעריך 1 2 3

9 עבור ה- compared הראשון שערכו שווה ל- control, נעריך את ה- actions. נחזיר את הערך של הביטוי האחרון בהן. אם לא קיים,compared אזי נעריך את ה- actions של ה- else. נחזיר את הערך של הביטוי האחרון בהן. (define (eval-case exp) (letrec ((eval-clauses (lambda (control clauses) (cond ((null? clauses) 'unspecified) ((or (case-last-clause? clauses) (= (applicative-eval (case-compared (case-first-clause clauses))) control)) (eval-sequence (case-actions (case-first-clause clauses)))) (else (eval-clauses control (case-rest-clauses clauses))))))) (eval-clauses (applicative-eval (case-control exp)) (case-clauses exp)))) המנתח הסינטקטי ASP Abstract Syntax Parser הממשק ה- ASP הוא ממשק בין קוד התוכנית לבין ה- core. מודול זה כולל פרוצדורות המחלצות את הרכיבים השונים ומזהות את סוג הביטוי. בשלב זה הביטויים לא מוערכים! נמשיך עם דוגמת ה- case ונוסיף אותו כביטוי חדש לשפה. הערה: הוספת תמיכה בביטוי חדש היא חובה ב- ASP, ולא תלויה בשאלה אם הביטוי החדש יהיה ביטוי נגזר או שהוא חלק מן הגרעין של השפה. נכתוב את ה- ADT עבור ביטוי,case הכולל בתוכו גם ADT עבור ה- case-clause. Constructor for case: make-case(control, case-clauses) Type: [Symbol * List(Clause-expression) -> CASE-Expression] Identification predicate: case?(exp) Type: [T > Boolean] Selectors: case-control(case-exp) Type: [CASE-Expression -> Symbol] case-clauses(case-exp) Type: [CASE-Expression -> List(Clause-expression)] Constructor for case clauses: make-case-clause(compared actions) Type: [T * List -> Clause-expression] 9

10 Selectors for case clauses: case-compared(clause) case-actions(clause) case-first-clause(case-exp) case-rest-clauses(case-exp) Identification predicate for case clauses: case-last-clause?(case-exp) דוגמה לשימוש ב- ADT ליצירת ביטוי ה- case שראינו קודם לכן: (make-case 'n (list (make-case-clause '0 '(0)) (make-case-clause '1 '(1)) (make-case-clause 'else '(+ (fib (- n 1)) (fib ( n 2)))))) (define case? (lambda (exp) (tagged-by? exp 'case))) עתה נראה את המימוש: (define make-case (lambda (control case-clauses) (attach-tag (cons control case-clauses) 'case))) (define case-control (lambda (case-exp) (car (get-content case-exp)))) (define case-clauses (lambda (case-exp) (cdr (get-content case-exp)))) (define make-case-clause (lambda (compared actions) (cons compared actions))) (define case-compared car) (define case-actions cdr) (define case-first-clause car) (define case-rest-clauses cdr) (define case-last-clause? (lambda (clauses) (and (null? (cdr clauses)) 10

11 (eq? (case-compared (case-first-clause clauses)) 'else)))) ביטויים נגזרים Sugar( )Syntactic חלק מהביטויים שראינו ב- scheme ניתנים להמרה על-ידי המנתח לביטוי אחר, שקול להם, בשביל הערכתו. ביטויים מסוג זה נקראים ביטויים נגזרים או סוכר תחבירי. מדוע כדאי לתרגם ביטויים מצורה א' לביטויים שקולים מצורה ב' ולא להעריך ביטויים מסוג א' באופן ישיר? למשל מפני שזה מותיר את ה- core קטן יותר. מתי לא נוכל להוסיף ביטוי חדש כביטוי נגזר? כאשר לא ניתן לתאר את הביטוי ואת החישוב שלו על-ידי ביטויים קיימים: בין אם פונקציות פרימיטיביות,,special forms ביטויי הפעלה, פרוצדורות, ושילובים ביניהם. נמשיך את הדוגמה של case ונבדוק אם ואיך אפשר להגדיר אותו כביטוי נגזר. דרך ראשונה: לפי חוק החישוב שהגדרנו ל- case, ביטוי השליטה e מחושב פעם אחת לפני בדיקת התנאים. לפי הגזירה הנ"ל e יחושב מספר פעמים. כדי לפתור בעיה זאת נראה דרך נוספת: האם התיקון פותר את כל המקרים? לא. (case e (1 (dosometing)) (2 (* e 2)) (else e)) (case e (1 (dosometing)) (2 (* e 2)) (else e)) (if (= e 1) (dosometing) (if (= e 2) (* e 2) e))) (let ((ex e)) (if (= ex 1) (dosometing) (if (= ex 2) (* ex 2) ex))) אמנם בסמנטיקה של,applicative eval ביטוי השליטה e יחושב לפני הפעלתו על הפרוצדורה ולכן צורה זה מתאימה לחוק החישוב שקבענו. לעומת זאת, בסמנטיקה של,normal eval גם גזירה זאת לא תתאים לחוק החישוב. לכן עבור case לא ניתן בשתי השיטות שראינו לגזור אותו לביטוי פשוט יותר מבלי לבצע חישובים מרובים של ביטוי השליטה. באינטרפטר, גזירה של ביטויים מתבצעת על-ידי הפניה הדדית בין הפרוצדורות derive ל- shallow-derive, כאשר shallow-derive מכילה את כללי הגזירה ה"בסיסיים" ו- derive דואגת להפעילם רקורסיבית עד אשר הביטוי מגיע לנקודת שבת: (define derive (lambda (exp) (if (atomic? exp) exp (let ((derived-exp (let ((mapped-derive-exp (map derive exp))) (if (not (derived? exp)) mapped-derive-exp (shallow-derive mapped-derive-exp))))) (if (equal? exp derived-exp) exp (derive derived-exp)))))) פרוצדורת derive פועלת על כל תת ביטוי בביטוי נתון. כשמסיימת לעבור על תתי הביטויים מפעילה את shallow-derive על הביטוי שחזר. 11

12 כדי לטפל בביטויים שנגזרים לביטויים נגזרים הגזירה הבאה של הביטוי שווה לביטוי עצמו. אחרים )לדוגמה: derive )let*,let מפעילה את עצמה על ביטוי מסוים עד אשר לכן, על מנת להוסיף ביטוי נגזר לשפה, יש לשנות את ה- ASP באופן הבא: הוספת הביטוי ל- shallow-derive - כתיבת התרגום מהביטוי הנגזר לביטוי הגזור )הבסיסי( - הוספת הביטוי ל-? derived - מבני נתונים )ds.rkt( מודול זה מכיל שלושה חלקים: )1( מבני הנתונים שהמעריך משתמש בהם לצורך החישוב של ביטויים החזקת הסביבה הגלובלית )3( מימוש של פרוצדורות ה- substitution. לאחר הערכתם. )2( מבני נתונים: מרכיב זה של המעריך מממש את מבני הנתונים שהמעריך משתמש בהם לצורך החישוב של ביטויים לאחר הערכתם. לדוגמה, נצטרך מבנה נתונים לתיאור פרוצדורות מכיוון שבשלב ההחלפה צריך לשלוף חלקים של הפרוצדורה המחושבת. דוגמה למבנה הנתונים של פרוצדורה: Signature: make-procedure (parameters, body) Type: [List(Symbol) * List -> Lambda-Expression] Signature: procedure-parameters (exp) Type: [Lambda-Expression -> List(Symbol)] Signature: procedure-body (exp) Type: [Lambda-Expression -> List] Signature: compound-procedure?(exp) Type: [T -> Boolean] הסביבה הגלובלית: בנוסף לכך, במודל זה מוחזקת הסביבה הגלובלית בה נשמרים הקישורים בין משתנים לבין ערכים וגם הפרוצדורות הפרימיטיבית. הפרוצדורה מייצרת החלפה )make-sub( בין רשימה של סימנים שמייצגים את הפרוצדורות הפרימיטיביות לבין הערכים ש- scheme נותן לנו לפרוצדורות הפרימיטיביות. נסתכל על סביבה הגלובלית: (define make-the-global-environment (lambda () (let* ((primitive-procedures (list (list 'car car) (list 'cdr cdr) (list 'cons cons) (list 'null? null?) (list '+ +) (list '* *) (list '/ /) (list '> >) (list '< <) (list '- -) (list '= =) 12

13 (list 'list list) (list 'append append) )) (prim-variables (map car primitive-procedures)) (prim-values (map (lambda (x) (make-primitive-procedure (cadr x))) primitive-procedures)) ) (make-sub prim-variables prim-values)))) למשל, נסתכל על הפרוצדורה אשר מחפשת ערך בסביבה: (define get-value-of-variable (lambda (sub var) (letrec ((lookup (lambda (vars vals) (cond ((or (empty-sub? sub) (not (member var vars))) (error 'get-value-of-variable)) ((eq? var (car vars)) (car vals)) (else (lookup (cdr vars) (cdr vals))))))) (lookup (get-variables sub) (get-values sub))))) :Substitution adt במודול זה גם מוגדר ה- ADT עבור פעולת ה- substitution. הממשק המלא מצורף כחומר עזר לעיון בסוף התרגול. אנחנו נתבונן במימוש של הפונקציה :substitute ; Signature: substitute(sub,expr) ; Purpose: Consistent replacement of all FREE ; occurrences of the substitution variables in ; 'expr' by the values of the substitution, respectively. ; 'expr' is a Scheme expression. ; Client Type: [Substitution * ; Scheme-expression union Evaluator-value -> ; Scheme-expression union Evaluator-value] ; Supplier Type: [List*(List union Symbol) -> List union Symbol] ; Example: (substitute ; (make-sub '(x y z) '(3 4 (lambda (x1)(+ x1 1)))) ; '(lambda (x2)(+ x2 y))) ) ==> (lambda (x2)(+ x2 4)) ; Pre-conditions: (1) substitution is not performed on ; 'define' or 'let' expressions or on ; expressions containing such sub-expressions. ; (2) 'expr' is already renamed. Therefore, ; the substitution variables have no bound ; occurrences in expr. (define substitute (lambda (expr variables values) (if (evaluator-value? expr) (substitution-application-to-value (make-sub variables values) expr) (substitution-application-to-expr (make-sub variables values) expr)))) (define substitution-application-to-expr (lambda (sub expr) 13

14 (cond ((empty-sub? sub) expr) ((or (number? expr) (boolean? expr) (quoted? expr)) expr) (else (let ((vars (get-variables sub)) (values (get-values sub))) (cond ((variable? expr) (if (member expr vars) (get-value-of-variable sub expr (lambda () expr)) expr)) (else ; expression is a list of ; expressions, lambda, application, cond. (map (lambda (e) (substitute e vars values)) expr)))))))) (define substitution-application-to-value (lambda (sub val-expr) (let ((vars (get-variables sub)) (values (get-values sub))) (cond ((primitive-procedure? val-expr) val-expr) ((value? val-expr) (if (atomic? (value-content val-expr)) val-expr (make-value (map (lambda (e) (substitute e vars values)) (value-content val-expr))))) ((compound-procedure? val-expr) (make-procedure (procedure-parameters val-expr) (map (lambda (e) (substitute e vars values)) (procedure-body val-expr)))))))) נספח לעיון ADT עבור.substitution ; Signature: make-sub(variables, values) ; Purpose: Create a substitution in which the i-th element of 'variables' ; is mapped to the i-th element of 'values'. ; Client Type: [List(Symbol) * List(Scheme-expression union Evaluator-value) -> ; Substitution] ; Supplier Type: [List(Symbol) * List(List union Symbol)) -> List] ; Example: (make-sub '(x y z) ; '(3 #t (lambda (x) (+ x 1))) ) ==> ; ((x y z) (3 #t (lambda (x) (+ x 1)))) ; Pre-condition: (length variables) = (length values) ; Signature: get-variables(sub) ; Type: Client view: [Sub -> List(Var)] ; Supplier view: [List -> List(Symbol)] ; Signature: get-values(sub) ; Type: Client view: [Sub -> List(Scheme-expression 14

15 ; union Evaluator-value)] ; Supplier view: [List -> List(List union Symbol)] ; Signature: get-value-of-variable(sub,var,fail-cont) ; Type: Client view: [Sub * Var * [Empty -> T] -> ; Scheme-expression union Evaluator-value] ; Supplier view: [List * Symbol * [Empty -> T] -> List union Symbol] ; Purpose: If sub is an empty substitution or does not ; includes var, fail-cont is applied. ; Signature: extend-sub(sub,var,value) ; Purpose: Adds var-value binding, if var is not ; already in sub. Otehrwise -- error ; Client Type: [Substitution * Var * ; Scheme-expression union Evaluator-value -> Substitution] ; Supplier Type: [List * Symbol * List union Symbol -> List] ; Signature: sub?(sub) ; Type: [T -> Boolean] ; Example: (sub? (make-sub '(x y z) ; '(3 #t (lambda (x)(+ x 1))) ) ==> #t ; (sub? (make-sub (list) (list))) ==> #t ; (sub? '()) ==> #f ; Signature: empty-sub?(sub) ; Type: [T -> Boolean] ; Example: (empty-sub? (make-sub '(x y z) ; (list 'Number 'Boolean ; '(3 #t (lambda (x)(+ x 1))) ) ==> #f ; (empty-sub? (make-sub (list) (list))) ==> #t ; Pre-condition: (sub? sub) ; Signature: non-empty-sub?(sub) ; Type: [T -> Boolean] ; Example: (non-empty-sub? (make-sub '(x y z) ; '(3 #t (lambda (x)(+ x 1))) ) ==> #t ; (non-empty-sub? (make-sub (list) (list))) ==> #f ; Pre-condition: (sub? sub) ; Signature: sub-equal?(sub1,sub2) ; Type: Client view: [Sub * Sub -> Boolean] ; Supplier view: [List * List -> Boolean] ; Example: (sub-equal? (make-sub '(x y z) ; '(3 #t (lambda (x)(+ x 1))) ) ; (make-sub '(y x z) ; '(#t 3 (lambda (x)(+ x 1))) ) ) ==> #t ; (sub-equal? (make-sub (list) (list)) (make-sub ; (list) (list)) ) ==> #t 15